home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gsdcolor.h < prev    next >
C/C++ Source or Header  |  1997-03-27  |  12KB  |  311 lines
  1. /* Copyright (C) 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gsdcolor.h */
  20. /* Device color representation for drivers */
  21.  
  22. #ifndef gsdcolor_INCLUDED
  23. #  define gsdcolor_INCLUDED
  24.  
  25. #include "gsccolor.h"
  26. #include "gxarith.h"        /* for imod */
  27. #include "gxbitmap.h"
  28. #include "gxhttile.h"
  29. #include "gxcindex.h"
  30.  
  31. #ifndef gx_device_color_DEFINED
  32. #  define gx_device_color_DEFINED
  33. typedef struct gx_device_color_s gx_device_color;
  34. #endif
  35.  
  36. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  37.  * The definitions in the following section of the file are the only
  38.  * ones that should be used by read-only clients such as implementors
  39.  * of high-level driver functions.
  40.  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  41.  
  42. /*
  43.  * A device color consists of a base color and an optional (tiled) mask.
  44.  * The base color may be a pure color, a binary halftone, or a colored
  45.  * bitmap (color halftone or colored Pattern).  The mask is used for
  46.  * both colored and uncolored Patterns.
  47.  */
  48.  
  49. /* Accessing a pure color. */
  50. #define gx_dc_is_pure(pdc)\
  51.   ((pdc)->type == gx_dc_type_pure)
  52. #define gx_dc_writes_pure(pdc, lop)\
  53.   (gx_dc_is_pure(pdc) && lop_no_S_is_T(lop))
  54. #define gx_dc_pure_color(pdc)\
  55.   ((pdc)->colors.pure)
  56.  
  57. /* Accessing the phase of a halftone. */
  58. #define gx_dc_phase(pdc)\
  59.   ((pdc)->phase)
  60.  
  61. /* Accessing a binary halftone. */
  62. #define gx_dc_is_binary_halftone(pdc)\
  63.   ((pdc)->type == gx_dc_type_ht_binary)
  64. #define gx_dc_binary_tile(pdc)\
  65.   (&(pdc)->colors.binary.b_tile->tiles)
  66. #define gx_dc_binary_color0(pdc)\
  67.   ((pdc)->colors.binary.color[0])
  68. #define gx_dc_binary_color1(pdc)\
  69.   ((pdc)->colors.binary.color[1])
  70.  
  71. /* Accessing a colored halftone. */
  72. #define gx_dc_is_colored_halftone(pdc)\
  73.   ((pdc)->type == gx_dc_type_ht_colored)
  74.  
  75. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  76.  * The definitions in the following section of the file, plus the ones
  77.  * just above, are the only ones that should be used by clients that
  78.  * set as well as read device colors.
  79.  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  80.  
  81. #define color_is_set(pdc)\
  82.   ((pdc)->type != gx_dc_type_none)
  83. #define color_unset(pdc)\
  84.   ((pdc)->type = gx_dc_type_none)
  85.  
  86. #define gx_dc_is_null(pdc)\
  87.   ((pdc)->type == gx_dc_type_null)
  88. #define color_is_null(pdc) gx_dc_is_null(pdc)
  89. #define color_set_null(pdc)\
  90.   ((pdc)->type = gx_dc_type_null)
  91.  
  92. #define color_is_pure(pdc) gx_dc_is_pure(pdc)
  93. #define color_writes_pure(pdc, lop) gx_dc_writes_pure(pdc, lop)
  94. #define color_set_pure(pdc, color)\
  95.   ((pdc)->colors.pure = (color),\
  96.    (pdc)->type = gx_dc_type_pure)
  97.  
  98. /* Set the phase to an offset from the tile origin. */
  99. #define color_set_phase(pdc, px, py)\
  100.   ((pdc)->phase.x = (px),\
  101.    (pdc)->phase.y = (py))
  102. /* Set the phase from the halftone phase in a graphics state. */
  103. #define color_set_phase_mod(pdc, px, py, tw, th)\
  104.   color_set_phase(pdc, imod(-(px), tw), imod(-(py), th))
  105.  
  106. #define color_is_binary_halftone(pdc) gx_dc_is_binary_halftone(pdc)
  107. #define color_set_binary_halftone(pdc, ht, color0, color1, level)\
  108.   ((pdc)->colors.binary.b_ht = (ht),\
  109.    (pdc)->colors.binary.color[0] = (color0),\
  110.    (pdc)->colors.binary.color[1] = (color1),\
  111.    (pdc)->colors.binary.b_level = (level),\
  112.    (pdc)->type = gx_dc_type_ht_binary)
  113. #define color_set_binary_tile(pdc, color0, color1, tile)\
  114.   ((pdc)->colors.binary.b_ht = 0,\
  115.    (pdc)->colors.binary.color[0] = (color0),\
  116.    (pdc)->colors.binary.color[1] = (color1),\
  117.    (pdc)->colors.binary.b_tile = (tile),\
  118.    (pdc)->type = gx_dc_type_ht_binary)
  119.  
  120. #define color_is_colored_halftone(pdc) gx_dc_is_colored_halftone(pdc)
  121. #define _color_set_c(pdc, i, b, l)\
  122.   ((pdc)->colors.colored.c_base[i] = (b),\
  123.    (pdc)->colors.colored.c_level[i] = (l))
  124. #define color_set_rgb_halftone(pdc, ht, br, lr, bg, lg, bb, lb, a)\
  125.   ((pdc)->colors.colored.c_ht = (ht),\
  126.    _color_set_c(pdc, 0, br, lr),\
  127.    _color_set_c(pdc, 1, bg, lg),\
  128.    _color_set_c(pdc, 2, bb, lb),\
  129.    (pdc)->colors.colored.alpha = (a),\
  130.    (pdc)->type = gx_dc_type_ht_colored)
  131. /* Some special clients set the individual components separately. */
  132. #define color_finish_set_cmyk_halftone(pdc, ht)\
  133.   ((pdc)->colors.colored.c_ht = (ht),\
  134.    (pdc)->colors.colored.alpha = max_ushort,\
  135.    (pdc)->type = gx_dc_type_ht_colored)
  136. #define color_set_cmyk_halftone(pdc, ht, bc, lc, bm, lm, by, ly, bk, lk)\
  137.    (_color_set_c(pdc, 0, bc, lc),\
  138.     _color_set_c(pdc, 1, bm, lm),\
  139.     _color_set_c(pdc, 2, by, ly),\
  140.     _color_set_c(pdc, 3, bk, lk),\
  141.     color_finish_set_cmyk_halftone(pdc, ht))
  142.  
  143. /* Note that color_set_null_pattern doesn't set mask.ccolor. */
  144. #define color_set_null_pattern(pdc)\
  145.  ((pdc)->mask.id = gx_no_bitmap_id,\
  146.   (pdc)->mask.m_tile = 0,\
  147.   (pdc)->colors.pattern.p_tile = 0,\
  148.   (pdc)->type = gx_dc_type_pattern)
  149.  
  150. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  151.  * The remaining definitions are internal ones that are included in this
  152.  * file only because C's abstraction mechanisms aren't strong enough to
  153.  * allow us to keep them separate and still have in-line access to the
  154.  * commonly used members.
  155.  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  156.  
  157. /* Define opaque types for objects referenced by device colors. */
  158.  
  159. #ifndef gx_ht_tile_DEFINED
  160. #  define gx_ht_tile_DEFINED
  161. typedef struct gx_ht_tile_s gx_ht_tile;
  162. #endif
  163.  
  164. #ifndef gx_device_halftone_DEFINED
  165. #  define gx_device_halftone_DEFINED
  166. typedef struct gx_device_halftone_s gx_device_halftone;
  167. #endif
  168.  
  169. #ifndef gx_color_tile_DEFINED
  170. #  define gx_color_tile_DEFINED
  171. typedef struct gx_color_tile_s gx_color_tile;
  172. #endif
  173.  
  174. /*
  175.  * The device color in the graphics state is computed from client color
  176.  * specifications, and kept current through changes in transfer function,
  177.  * device, and (if relevant) halftone phase.
  178.  * (gx_set_dev_color sets the device color if needed.)
  179.  * For binary halftones (and eventually colored halftones as well),
  180.  * the bitmaps are only cached, so internal clients (the painting operators)
  181.  * must call gx_color_load to ensure that the bitmap is available.
  182.  * Device color elements set by gx_color_load are marked with @ below.
  183.  *
  184.  * Base colors are represented as follows:
  185.  *
  186.  *    Pure color (gx_dc_pure):
  187.  *        colors.pure = the color;
  188.  *    Binary halftone (gx_dc_ht_binary):
  189.  *        colors.binary.b_ht = the device halftone;
  190.  *        colors.binary.color[0] = the color for 0s (darker);
  191.  *        colors.binary.color[1] = the color for 1s (lighter);
  192.  *        colors.binary.b_level = the number of pixels to lighten,
  193.  *          0 < halftone_level < P, the number of pixels in the tile;
  194.  *    @    colors.binary.b_tile points to an entry in the binary
  195.  *          tile cache.
  196.  *    Colored halftone (gx_dc_ht_colored):
  197.  *        colors.colored.c_ht = the device halftone;
  198.  *        colors.colored.c_level[0..N-1] = the halftone levels,
  199.  *          like b_level;
  200.  *        colors.colored.c_base[0..N-1] = the base colors;
  201.  *          N=3 for RGB devices, 4 for CMYK devices;
  202.  *          0 <= c_level[i] < P;
  203.  *          0 <= c_base[i] <= dither_rgb;
  204.  *        colors.colored.alpha = the opacity.
  205.  *    Colored pattern (gx_dc_pattern):
  206.  *        (id and mask are also set, see below)
  207.  *    @    colors.pattern.p_tile points to a gx_color_tile in
  208.  *          the pattern cache, or is NULL for a null pattern.
  209.  *
  210.  * The phase element is used for all colors except pure ones.  It holds
  211.  * the negative of the graphics state halftone phase, modulo the halftone
  212.  * tile or colored pattern size.
  213.  *
  214.  * The mask elements of a device color are only used for patterns:
  215.  *    Non-pattern:
  216.  *        mask is unused.
  217.  *    Pattern:
  218.  *        mask.ccolor gives the original Pattern color (needed for
  219.  *          reloading the pattern cache);
  220.  *        mask.id gives the ID of the pattern (and its mask);
  221.  *    @    mask.m_tile points to a gx_color_tile in the pattern cache,
  222.  *          or is NULL for a pattern that doesn't require a mask.
  223.  *          (The 'bits' of the tile are not accessed.)
  224.  *          For colored patterns requiring a mask, p_tile and
  225.  *          mask.m_tile point to the same cache entry.
  226.  * For masked colors, gx_set_dev_color replaces the type with a different
  227.  * type that applies the mask when painting.  These types are not defined
  228.  * here, because they are only used in Level 2.
  229.  */
  230.  
  231. /* A device color type is just a pointer to the procedures. */
  232. typedef struct gx_device_color_procs_s gx_device_color_procs;
  233. typedef const gx_device_color_procs _ds *gx_device_color_type;
  234.  
  235. struct gx_device_color_s {
  236.     /*
  237.      * Since some compilers don't allow static initialization of a
  238.      * union, we put the type first.
  239.      */
  240.     gx_device_color_type type;
  241.     /*
  242.      * See the comment above for descriptions of the members.  We use
  243.      * b_, c_, and p_ member names because some old compilers don't
  244.      * allow the same name to be used for two different structure
  245.      * members even when it's unambiguous.
  246.      */
  247.     union _c {
  248.         gx_color_index pure;
  249.         struct _bin {
  250.             const gx_device_halftone *b_ht;
  251.             gx_color_index color[2];
  252.             uint b_level;
  253.             gx_ht_tile *b_tile;
  254.         } binary;
  255.         struct _col {
  256.             const gx_device_halftone *c_ht;
  257.             byte c_base[4];
  258.             uint c_level[4];
  259.             ushort /*gx_color_value*/ alpha;
  260.         } colored;
  261.         struct _pat {
  262.             gx_color_tile *p_tile;
  263.         } /*(colored)*/ pattern;
  264.     } colors;
  265.     gs_int_point phase;
  266.     struct _mask {
  267.       gs_client_color ccolor;    /* needed for remapping pattern */
  268.       gx_bitmap_id id;
  269.       gx_color_tile *m_tile;
  270.     } mask;
  271. };
  272. /*extern_st(st_device_color);*/        /* in gxdcolor.h */
  273. #define public_st_device_color() /* in gxcmap.c */\
  274.   gs_public_st_composite(st_device_color, gx_device_color, "gx_device_color",\
  275.     device_color_enum_ptrs, device_color_reloc_ptrs)
  276. #define st_device_color_max_ptrs 2
  277.  
  278. /*
  279.  * Define the standard device color types.
  280.  * We define them here as pointers to the real types only because a few
  281.  * C compilers don't allow declaring externs with abstract struct types;
  282.  * we redefine them as macros in gxdcolor.h where the concrete type for
  283.  * gx_device_color_procs is available.
  284.  * We spell out the definition of gx_device_color type because some
  285.  * C compilers can't handle the typedef correctly.
  286.  */
  287. #ifndef gx_dc_type_none
  288. extern const gx_device_color_procs _ds *gx_dc_type_none;  /* gxdcolor.c */
  289. #endif
  290. #ifndef gx_dc_type_null
  291. extern const gx_device_color_procs _ds *gx_dc_type_null;  /* gxdcolor.c */
  292. #endif
  293. #ifndef gx_dc_type_pure
  294. extern const gx_device_color_procs _ds *gx_dc_type_pure;  /* gxdcolor.c */
  295. #endif
  296.         /*
  297.          * We don't declare gx_dc_pattern here, so as not to create
  298.          * a spurious external reference in Level 1 systems.
  299.          */
  300. #ifndef gx_dc_type_pattern
  301. /*extern const gx_device_color_procs _ds *gx_dc_type_pattern;*/  /* gspcolor.c */
  302. #endif
  303. #ifndef gx_dc_type_ht_binary
  304. extern const gx_device_color_procs _ds *gx_dc_type_ht_binary;  /* gxht.c */
  305. #endif
  306. #ifndef gx_dc_type_ht_colored
  307. extern const gx_device_color_procs _ds *gx_dc_type_ht_colored;  /* gxcht.c */
  308. #endif
  309.  
  310. #endif                    /* gsdcolor_INCLUDED */
  311.